home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / programm / MM2_DEV / S / MOS / LOADER.D < prev    next >
Encoding:
Modula Definition  |  1990-11-26  |  10.2 KB  |  218 lines
  1. DEFINITION MODULE Loader;
  2.  
  3. (* Erstellt 25.10.86 von TT *)
  4.  
  5. FROM SYSTEM IMPORT ADDRESS;
  6.  
  7. FROM MOSGlobals IMPORT NameStr;
  8.  
  9. FROM Lists IMPORT List;
  10.  
  11. FROM PathCtrl IMPORT PathList;
  12.  
  13.  
  14. TYPE    LoaderResults = ( noError,      (* Kein Fehler *)
  15.                           notFound,     (* Datei nicht gefunden *)
  16.                           badFile,      (* Lesefehler der Datei *)
  17.                           badData,      (* Fehler in Dateidaten *)
  18.                           badLayout,    (* Datei ist kein Modul bzw. Prg. *)
  19.                           badVersion,   (* Module haben verschiedene Keys *)
  20.                           notLinkable,  (* Import. Modul ist komprimiert *)
  21.                           outOfMemory,  (* Kein Speicherplatz mehr *)
  22.                           wrongRealForm,(* Falsches Real-Format *)
  23.                           wrongFPUType, (* FPU ist nicht vorhanden *)
  24.                           tooManyCalls, (* Zu viele Programme gestartet *)
  25.                           tooManyMods,  (* Zu viele Module zu starten *)
  26.                           initFault,    (* Fehler während Initialisierung *)
  27.                           exitFault,    (* Fehler während Deinitialisierung *)
  28.                           notRemoved,   (* Bei Unload: hat noch Klienten *)
  29.                           denied );     (* Bei Call: residentes Modul, *)
  30.                                         (*  bei Unload: Nicht geladen. *)
  31.  
  32.         LoadingProc = PROCEDURE ( REF (* modName:  *) ARRAY OF CHAR,
  33.                                   REF (* fileName: *) ARRAY OF CHAR,
  34.                                       (* modAddr:  *) ADDRESS,
  35.                                       (* modLen:   *) LONGCARD,
  36.                                       (* varAddr:  *) ADDRESS,
  37.                                       (* varLen:   *) LONGCARD );
  38.  
  39.  
  40. VAR DefaultStackSize: LONGCARD;  (* >=1024, default=16384 *)
  41.       (*
  42.        * Stack-Größe, die einem Programm zugeteilt wird, das mit
  43.        * 'CallModule' gestartet wird. Allerdings nur bei Programmen,
  44.        * die aus einzelnen Modulen bestehen - bei bereits gelinkten
  45.        * Programmen ist die Stack-Größe vorbestimmt und kann nicht mehr
  46.        * beim Starten verändert werden. Siehe auch 'LoadModule'.
  47.        *)
  48.  
  49.     NoPaths: PathList;          (* leere Pfadliste (s.u.) *)
  50.       (*
  51.        * Diese Variable kann bei 'LoadModule' und 'CallModule'
  52.        * angegeben werden, wenn keine Pfadliste benötigt wird.
  53.        * Das ist der Fall, wenn entweder ein gelinktes Programm
  54.        * geladen/gestartet wird oder wenn die importierten Module
  55.        * schon alle in den Speicher geladen sind (z.B. resident
  56.        * sind) oder wenn sie im aktuellen Verzeichnis liegen.
  57.        *)
  58.  
  59.     Monitor: PROC;
  60.       (*
  61.        * Wird aufgerufen, bevor das Hauptmodul beim 'CallModule'-Aufruf
  62.        * gestartet wird. Siehe Modul "Monitor" im UTILITY-Ordner.
  63.        *)
  64.  
  65.     Loading: LoadingProc;
  66.       (*
  67.        * Wird nach dem erfolgreichen Laden eines importierten Moduls
  68.        * aufgerufen. Siehe Modul "ModTrace" im UTILITY-Ordner.
  69.        *)
  70.  
  71.  
  72.  
  73. PROCEDURE IsModule ( REF fileName: ARRAY OF CHAR ): BOOLEAN;
  74.   (*
  75.    * Liefert TRUE, wenn die angegebene Diskdatei ein Modul ist,
  76.    * das von diesem Loader geladen (bzw. gestartet) werden kann.
  77.    * Bei Programmdateien liefert es FALSE, obwohl sie ebenfalls
  78.    * vom Loader geladen/gestartet werden können.
  79.    *)
  80.  
  81. PROCEDURE CallModule ( REF fileName : ARRAY OF CHAR;
  82.                            paths    : PathList;
  83.                        REF arg      : ARRAY OF CHAR;
  84.                            env      : ADDRESS;
  85.                        VAR exitCode : INTEGER;
  86.                        VAR errMsg   : ARRAY OF CHAR;  (* 80 Zeichen max. *)
  87.                        VAR result   : LoaderResults);
  88.   (*
  89.    * Ruft Modul 'fileName' als Unterprogramm auf. Wenn es sich noch nicht im
  90.    * Speicher befindet, wird versucht, es vom angegebenen Directory-Pfad
  91.    * zu laden. Wird es dort nicht gefunden, werden, sofern 'paths' nicht
  92.    * leer ist, alle Directories, die in 'paths' angegeben sind, in der
  93.    * bestimmten Reihenfolge durchsucht.
  94.    *
  95.    * Werden Module importiert, die sich noch nicht geladen sind, werden
  96.    * sie in allen Directories, die in 'paths' bestimmt sind, gesucht. Da-
  97.    * bei wird der gesuchte Dateiname aus den ersten 8 Zeichen des Modul-
  98.    * namens und der Extension ".IMP" (kann im 'MOSConfig' unbenannt werden)
  99.    * gebildet. Die geladenen Module werden dabei alle unter dem neu erzeug-
  100.    * ten Prozeß gestartet.
  101.    *
  102.    * Wird ein gelinktes Programm gestartet, oder befinden sich alle Module
  103.    * im aktuellen Verzeichnis, kann durch 'NoPaths' bequem eine leere
  104.    * Suchliste angegeben werden.
  105.    *
  106.    * 'arg' ist ein String, der als Argumentstring an das Modul übergeben
  107.    * wird. Der String sollte nur aus normal lesbarem Text bestehen, braucht
  108.    * also nicht im ersten Zeichen das Längenbyte enthalten, wie es bei der
  109.    * Pexec-Funktion nötig ist. Nur die ersten 125 Zeichen werden weitergegeben.
  110.    * Wenn allerdings das erste Zeichen im 'arg'-String CHR(127) ist, wird dies
  111.    * als ARGV-Methode (damit können Argumentzeilen mit mehr als 125 Zeichen
  112.    * übergeben werden) verstanden und die Zeile wird unverändert ans gerufene
  113.    * Programm übergeben. Die Argumentzeile muß dann gemäß dem ARGV-Verfahren
  114.    * zum Teil im Environment übergeben werden. Mehr dazu finden Sie in den
  115.    * Dokumentationen von Atari (GEMDOS extended argument (ARGV) specification).
  116.    *
  117.    * 'env' ist ein Zeiger auf ein selbsterzeugtes Environment. Falls Sie
  118.    * nicht wissen, wozu das gut ist, oder kein eigenes erzeugen wollen,
  119.    * übergeben Sie NIL!
  120.    *
  121.    * Wenn das Programm normal beendete, enthält 'exitCode' Null. Wenn das
  122.    * Programm mit einem Laufzeitfehler abbrach, enthält 'exitCode' die
  123.    * Fehlernummer (siehe Modul 'MOSConfig'). Wenn das Programm mit der
  124.    * Funktion 'PrgCtrl.TermProcess' endete, enthält 'exitCode' den dort
  125.    * übergebenen Wert.
  126.    *
  127.    * 'result' enthält nach Aufruf der Prozedur eine Meldung, ob das
  128.    * Modul ausgeführt werden konnte (dies ist nur der Fall, wenn der Wert
  129.    * 'noError' oder 'exitFault' ist).
  130.    * Wenn 'result' ungleich 'noError' ist, dann wird in 'errMsg' eine
  131.    * Fehlermeldung geliefert.
  132.    *)
  133.  
  134. PROCEDURE LoadModule ( REF fileName: ARRAY OF CHAR;
  135.                            paths   : PathList;
  136.                        VAR modName : ARRAY OF CHAR;
  137.                        VAR errMsg  : ARRAY OF CHAR;
  138.                        VAR result  : LoaderResults);
  139.   (*
  140.    * Lädt Modul "fileName" mitsamt aller importierten Module in den Speicher,
  141.    * falls sie sich nicht schon dort befinden. Der Suchvorgang ist derselbe
  142.    * wie bei "CallModule".
  143.    *
  144.    * Das Modul kann dann mit "CallModule" aufgerufen werden, ohne daß es
  145.    * nochmal geladen werden muß. Nachdem das mit "CallModule" aufgerufene
  146.    * Modul beendet ist, bleibt es weiterhin im Speicher, bis es durch
  147.    * "UnLoadModule" freigegeben wird.
  148.    *
  149.    * "modName" liefert nach dem Funktionsaufruf den vollständigen Namen
  150.    * des geladenen Moduls. Er ist z.B. bei "UnloadModule" anzugeben.
  151.    * Werden Module importiert, die noch nicht geladen sind, werden sie
  152.    * sofort mitgeladen aber nicht initialisiert. Wird "fileName" dann mit
  153.    * "CallModule" gestartet, werden die importierten Module initialisiert
  154.    * und bekommen am Ende wieder den Zustand 'nicht initialisiert', damit
  155.    * sie bei erneutem "CallModule"-Aufruf wieder initialisiert werden.
  156.    * "result" enthält nach Aufruf der Prozedur eine Meldung, ob das
  157.    * Modul geladen werden konnte.
  158.    *
  159.    * Wenn "result" ungleich "noError" ist, dann wird in "errMsg" eine
  160.    * Fehlermeldung geliefert.
  161.    *
  162.    * "LoadModule" darf mehrmals hintereinander aufgerufen werden, dann
  163.    * liefert "result" "denied".
  164.    *
  165.    * Wird ein bereits gelinktes Programm (Endungen TOS, PRG usw.) geladen,
  166.    * muß aus technischen Gründen der Stack, den das Programm später beim
  167.    * Start benützen wird, schon hier reserviert werden. Da es nicht
  168.    * möglich ist, die Stackgröße des Programms beim Laden zu ermitteln,
  169.    * wird immer soviel reserviert, wie 'DefaultStackSize' (s.o.) angibt.
  170.    * Wenn sich ein geladenes, gelinktes Programm beim Starten anders
  171.    * verhält (wenn z.B. ungewohnte Fehler auftreten), als das gleiche,
  172.    * wenn es vor dem Start nicht mit 'CallModule' geladen wird, dann ist
  173.    * zuerst versuchsweise der Wert in 'DefaultStackSize' zu erhöhen. Der
  174.    * erforderliche Wert kann u.U. auch einige hundert KByte betragen.
  175.    *)
  176.  
  177. PROCEDURE UnLoadModule ( REF modName : ARRAY OF CHAR;
  178.                          VAR result  : LoaderResults);
  179.   (*
  180.    * Gibt das Modul 'modName' zur Freigabe aus dem Speicher frei.
  181.    * Die Freigabe erfolgt immer unabhängig davon, wie oft worher
  182.    * 'LoadModule' aufgerufen wurde. Allerdings kann es sein, daß das
  183.    * Modul nicht sofort aus dem Speicher verschwindet, weil es z.B.
  184.    * noch von anderen Modulen importiert wird oder gerade gestartet
  185.    * wurde und noch nicht endete.
  186.    * 'result' kann die folgenden Werte liefern:
  187.    *   'noError'   : Modul ist entfernt worden.
  188.    *   'notRemoved': Modul bleibt weiterhin im Speicher, da es importiert wird.
  189.    *   'denied'    : Modul war nicht im Speicher vorhanden.
  190.    *)
  191.  
  192. PROCEDURE SetChain ( REF fileName, arg : ARRAY OF CHAR );
  193.   (*
  194.    * Definiert Modul 'fileName' als Nachfolger nach Modul-Beendigung des
  195.    * aktiven Moduls.
  196.    *
  197.    * 'arg' ist ein String, der als Argumentstring an das nachfolgende
  198.    * Modul übergeben wird (nicht mehr als 127 Zeichen !).
  199.    *
  200.    * Diese Funktion kann mehrmals im selben Modullevel aufgerufen werden,
  201.    * jeder Neuaufruf macht dabei den Vorherigen rückgängig.
  202.    *
  203.    * Ist 'fileName' ein Leerstring, dann wird damit die Funktion wieder
  204.    * rückgängig gemacht.
  205.    *
  206.    * Das nachfolgende Modul wird in jedem Fall gestartet, auch wenn
  207.    * das bisher aktive mit einem Fehler beendet.
  208.    *
  209.    * Vorsicht: Sollte nach Beendigung des Moduls, das diese Funktion
  210.    * aufrief, das angegebene Nachfolgemodul nicht geladen werden können,
  211.    * wird zum Aufrufer von 'CallMod' mit einer Fehlermeldung in 'result'
  212.    * zurückgekehrt, ohne daß dieser erfährt, daß nicht das von ihm aufge-
  213.    * rufene Modul den Fehler verursachte. Lediglich der Fehlermeldungs-
  214.    * text kannn darüber Aufschluß geben.
  215.    *)
  216.  
  217. END Loader.
  218.